home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / apache / bin / apxs.bat < prev    next >
DOS Batch File  |  2005-05-30  |  25KB  |  813 lines
  1. @rem = '--*-Perl-*--
  2. @echo off
  3. if "%OS%" == "Windows_NT" goto WinNT
  4. perl -x -S "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9
  5. goto endofperl
  6. :WinNT
  7. perl -x -S %0 %*
  8. if NOT "%COMSPEC%" == "%SystemRoot%\system32\cmd.exe" goto endofperl
  9. if %errorlevel% == 9009 echo You do not have Perl in your PATH.
  10. if errorlevel 1 goto script_failed_so_exit_with_non_zero_val 2>nul
  11. goto endofperl
  12. @rem ';
  13. #!C:\xampp\perl\bin\perl.EXE -w
  14. #line 15
  15. # ====================================================================
  16. #
  17. #  Copyright 2003-2004  The Apache Software Foundation
  18. #
  19. #  Licensed under the Apache License, Version 2.0 (the "License");
  20. #  you may not use this file except in compliance with the License.
  21. #  You may obtain a copy of the License at
  22. #
  23. #      http://www.apache.org/licenses/LICENSE-2.0
  24. #
  25. #  Unless required by applicable law or agreed to in writing, software
  26. #  distributed under the License is distributed on an "AS IS" BASIS,
  27. #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  28. #  See the License for the specific language governing permissions and
  29. #  limitations under the License.
  30.  
  31. # apxs script designed to allow easy command line access to Apache
  32. # configuration parameters.
  33.  
  34. require 5.003;
  35. use strict;
  36. package apxs;
  37. use File::Copy;
  38. use File::Spec::Functions;
  39.  
  40. ##
  41. ##  Configuration
  42. ##
  43.  
  44. my %config_vars = ();
  45.  
  46. my $installbuilddir = 'O:\apache\build';
  47. get_config_vars("$installbuilddir/config_vars.mk",\%config_vars);
  48.  
  49. # read the configuration variables once
  50.  
  51. my $prefix          = get_vars('prefix');
  52. my $CFG_PREFIX      = $prefix;
  53. my $exec_prefix     = get_vars('exec_prefix');
  54. my $datadir         = get_vars('datadir');
  55. my $localstatedir   = get_vars('localstatedir');
  56. my $CFG_TARGET      = get_vars('progname');
  57. my $CFG_SYSCONFDIR  = get_vars('sysconfdir');
  58. my $CFG_SYSCONF     = get_vars('sysconf');
  59. my $CFG_CFLAGS      = join ' ', map { get_vars($_) }
  60.     qw(SHLTCFLAGS CFLAGS NOTEST_CPPFLAGS EXTRA_CPPFLAGS EXTRA_CFLAGS);
  61. my $includedir      = get_vars('includedir');
  62. my $CFG_INCLUDEDIR  = $includedir;
  63. my $libdir          = get_vars('libdir');
  64. my $CFG_LIBDIR      = $libdir;
  65. my $CFG_CC          = get_vars('CC');
  66. my $CFG_LD          = get_vars('LD');
  67. my $CFG_LDFLAGS     = get_vars('LDFLAGS');
  68. my $libexecdir      = get_vars('libexecdir');
  69. my $CFG_LIBEXECDIR  = $libexecdir;
  70. my $sbindir         = get_vars('sbindir');
  71. my $CFG_SBINDIR     = $sbindir;
  72. my $ltflags         = $ENV{LTFLAGS};
  73. my $apr_libname     = get_vars('APR_LIBNAME');
  74. my $aprutil_libname = get_vars('APRUTIL_LIBNAME');
  75.  
  76. $ltflags or $ltflags = '--silent';
  77.  
  78. my %internal_vars = map {$_ => 1}
  79.     qw(TARGET CC CFLAGS CFLAGS_SHLIB LD_SHLIB LDFLAGS_SHLIB LIBS_SHLIB
  80.        PREFIX SBINDIR INCLUDEDIR LIBEXECDIR SYSCONFDIR SYSCONF);
  81.  
  82. my $CP    = 'C:\xampp\perl\bin\perl.EXE -MExtUtils::Command -e cp';
  83. my $CHMOD = 'C:\xampp\perl\bin\perl.EXE -MExtUtils::Command -e chmod';
  84. my $RM_F  = 'C:\xampp\perl\bin\perl.EXE -MExtUtils::Command -e rm_f';
  85. my $TOUCH = 'C:\xampp\perl\bin\perl.EXE -MExtUtils::Command -e touch';
  86.  
  87. ##
  88. ##  parse argument line
  89. ##
  90.  
  91. #   defaults for parameters
  92. my $opt_n = '';
  93. my $opt_g = '';
  94. my $opt_c = 0;
  95. my $opt_o = '';
  96. my @opt_D = ();
  97. my @opt_I = ();
  98. my @opt_L = ();
  99. my @opt_l = ();
  100. my @opt_W = ();
  101. my @opt_S = ();
  102. my $opt_e = 0;
  103. my $opt_i = 0;
  104. my $opt_a = 0;
  105. my $opt_A = 0;
  106. my $opt_q = 0;
  107. my $opt_h = 0;
  108. my $opt_p = 0;
  109. my $opt_d = 0;
  110.  
  111. #   this subroutine is derived from Perl's getopts.pl with the enhancement of
  112. #   the "+" metacharacter at the format string to allow a list to be built by
  113. #   subsequent occurrences of the same option.
  114. sub Getopts {
  115.     my ($argumentative, @ARGV) = @_;
  116.     my $errs = 0;
  117.     local $_;
  118.     local $[ = 0;
  119.  
  120.     my @args = split / */, $argumentative;
  121.     while (@ARGV && ($_ = $ARGV[0]) =~ /^-(.)(.*)/) {
  122.         my ($first, $rest) = ($1,$2);
  123.         if ($_ =~ m|^--$|) {
  124.             shift @ARGV;
  125.             last;
  126.         }
  127.         my $pos = index($argumentative,$first);
  128.         if ($pos >= $[) {
  129.             if ($pos < $#args && $args[$pos+1] eq ':') {
  130.                 shift @ARGV;
  131.                 if ($rest eq '') {
  132.                     unless (@ARGV) {
  133.                         error("Incomplete option: $first (needs an argument)");
  134.                         $errs++;
  135.                     }
  136.                     $rest = shift(@ARGV);
  137.                 }
  138.                 eval "\$opt_$first = \$rest;";
  139.             }
  140.             elsif ($pos < $#args && $args[$pos+1] eq '+') {
  141.                 shift @ARGV;
  142.                 if ($rest eq '') {
  143.                     unless (@ARGV) {
  144.                         error("Incomplete option: $first (needs an argument)");
  145.                         $errs++;
  146.                     }
  147.                     $rest = shift(@ARGV);
  148.                 }
  149.                 eval "push(\@opt_$first, \$rest);";
  150.             }
  151.             else {
  152.                 eval "\$opt_$first = 1";
  153.                 if ($rest eq '') {
  154.                     shift(@ARGV);
  155.                 }
  156.                 else {
  157.                     $ARGV[0] = "-$rest";
  158.                 }
  159.             }
  160.         }
  161.         else {
  162.             error("Unknown option: $first");
  163.             $errs++;
  164.             if ($rest ne '') {
  165.                 $ARGV[0] = "-$rest";
  166.             }
  167.             else {
  168.                 shift(@ARGV);
  169.             }
  170.         }
  171.     }
  172.     return ($errs == 0, @ARGV);
  173. }
  174.  
  175. sub usage {
  176.     print STDERR <<'END';
  177. Usage: apxs -g [-S <var>=<val>] -n <modname>
  178.        apxs -q [-S <var>=<val>] <query> ...
  179.        apxs -c [-S <var>=<val>] [-o <dsofile>] [-D <name>[=<value>]]
  180.                [-I <incdir>] [-L <libdir>] [-l <libname>] [-Wc,<flags>]
  181.                [-Wl,<flags>] [-p] <files> ...
  182.        apxs -i [-S <var>=<val>] [-a] [-A] [-n <modname>] <dsofile> ...
  183.        apxs -e [-S <var>=<val>] [-a] [-A] [-n <modname>] <dsofile> ...
  184.  
  185. END
  186.     exit(1);
  187. }
  188.  
  189. #   option handling
  190. my $rc;
  191. ($rc, @ARGV) = &Getopts("qn:gco:I+D+L+l+W+S+eiaApd", @ARGV);
  192. &usage if ($rc == 0);
  193. &usage if ($#ARGV == -1 and not $opt_g);
  194. &usage if (not $opt_q and not ($opt_g and $opt_n) 
  195.            and not $opt_i and not $opt_c and not $opt_e);
  196.  
  197. #   argument handling
  198. my @args = @ARGV;
  199. my $name = 'unknown';
  200. $name = $opt_n if ($opt_n ne '');
  201.  
  202. if (@opt_S) {
  203.     my ($opt_S);
  204.     foreach $opt_S (@opt_S) {
  205.         if ($opt_S =~ m/^([^=]+)=(.*)$/) {
  206.             my ($var) = $1;
  207.             my ($val) = $2;
  208.             my $oldval = eval "\$CFG_$var";
  209.  
  210.             unless ($var and $oldval) {
  211.                 print STDERR "apxs:Error: no config variable $var\n";
  212.                 &usage;
  213.             }
  214.  
  215.             eval "\$CFG_${var}=\"${val}\"";
  216.         } else {
  217.             print STDERR "apxs:Error: malformatted -S option\n";
  218.             &usage;
  219.         }    
  220.     }
  221. }
  222.  
  223. ##
  224. ##  Initial shared object support check
  225. ##
  226. my $httpd = catfile get_vars("sbindir"), get_vars("progname");
  227. my $envvars = catfile get_vars("sbindir"), "envvars";
  228.  
  229. #allow apxs to be run from the source tree, before installation
  230. if ($0 =~ m:support/apxs$:) {
  231.     ($httpd = $0) =~ s:support/apxs$::;
  232. }
  233.  
  234. unless (-f $httpd) {
  235.     error("$httpd not found or not executable");
  236.     exit 1;
  237. }
  238.  
  239. sub get_config_vars{
  240.     my ($file, $rh_config) = @_;
  241.  
  242.     open IN, $file or die "cannot open $file: $!";
  243.     while (<IN>){
  244.         if (/^\s*(.*?)\s*=\s*(.*)$/){
  245.             $rh_config->{$1} = $2;
  246.         }
  247.     }
  248.     close IN;
  249. }
  250.  
  251. sub get_vars {
  252.     my $result = '';
  253.     my $ok = 0;
  254.     my $arg;
  255.     foreach $arg (@_) {
  256.         if (exists $config_vars{$arg} or exists $config_vars{lc $arg}) {
  257.             my $val = exists $config_vars{$arg}
  258.                 ? $config_vars{$arg}
  259.                     : $config_vars{lc $arg};
  260.             $val =~ s/[()]//g;
  261.             $result .= $val if defined $val;
  262.             $result .= ";;"; 
  263.             $ok = 1;
  264.         }
  265.         if (not $ok) {
  266.             if (exists $internal_vars{$arg} 
  267.                 or exists $internal_vars{lc $arg}) {
  268.                 my $val = exists $internal_vars{$arg} ? $arg : lc $arg;
  269.                 $val = eval "\$CFG_$val";
  270.                 $result .= $val if defined $val;
  271.                 $result .= ";;";
  272.                 $ok = 1;
  273.             }
  274.             if (not $ok) {
  275.                 error("Invalid query string `$arg'");
  276.                 exit(1);
  277.             }
  278.         }
  279.     }
  280.     $result =~ s|;;$||;
  281.     #    $result =~ s|:| |;
  282.     return $result;
  283. }
  284.  
  285. ##
  286. ##  Operation
  287. ##
  288.  
  289. #   helper function for executing a list of
  290. #   system command with return code checks
  291. sub execute_cmds {
  292.     my (@cmds) = @_;
  293.     my ($cmd, $rc);
  294.  
  295.     foreach $cmd (@cmds) {
  296.         notice($cmd);
  297.         $rc = system $cmd;
  298.         if ($rc) {
  299.             error(sprintf "Command failed with rc=%d\n", $rc << 8);
  300.             exit 1 ;
  301.         }
  302.     }
  303. }
  304.  
  305. if ($opt_g) {
  306.     ##
  307.     ##  SAMPLE MODULE SOURCE GENERATION
  308.     ##
  309.  
  310.     if (-d $name) {
  311.         error("Directory `$name' already exists. Remove first");
  312.         exit(1);
  313.     }
  314.  
  315.     my $data = join('', <DATA>);
  316.     $data =~ s!__END__.*!!s;
  317.     $data =~ s|%NAME%|$name|sg;
  318.     $data =~ s|%SYSCONF%|$CFG_SYSCONF|sg;
  319.     $data =~ s|%PREFIX%|$prefix|sg;
  320.     $data =~ s|%INSTALLBUILDDIR%|$installbuilddir|sg;
  321.  
  322.     my ($mkf, $src) = ($data =~ m|^(.+)-=\#=-\n(.+)|s);
  323.  
  324.     notice("Creating [DIR]  $name");
  325.     mkdir $name or die "Cannot mkdir $name: $!";
  326.     notice("Creating [FILE] $name/Makefile");
  327.     open(FP, ">${name}/Makefile") or die "Cannot open ${name}/Makefile: $!";
  328.     print FP $mkf;
  329.     close(FP);
  330.     notice("Creating [FILE] $name/mod_$name.c");
  331.     open(FP, ">${name}/mod_${name}.c") || die;
  332.     print FP $src;
  333.     close(FP);
  334.     notice("Creating [FILE] $name/.deps");
  335.     open(FP, ">${name}/.deps") or die "Cannot open ${name}/.deps: $!";
  336.     close(FP);
  337.  
  338.     exit(0);
  339. }
  340.  
  341. if ($opt_q) {
  342.     ##
  343.     ##  QUERY INFORMATION 
  344.     ##
  345.     my $result = get_vars(@args);
  346.     print "$result\n";
  347. }
  348.  
  349. my $apr_bindir = get_vars("APR_BINDIR");
  350. my $apu_bindir = get_vars("APU_BINDIR");
  351.  
  352. my $apr_includedir = qq{-I"$prefix/include"};
  353. my $apu_includedir = qq{-I$"prefix/include"};
  354.  
  355. if ($opt_c) {
  356.     ##
  357.     ##  SHARED OBJECT COMPILATION
  358.     ##
  359.     
  360.     #   split files into sources and objects
  361.     my @srcs = ();
  362.     my @objs = ();
  363.     my $f;
  364.     foreach $f (@args) {
  365.         if ($f =~ m|\.c$|) {
  366.             push(@srcs, $f);
  367.         }
  368.         else {
  369.             push(@objs, $f);
  370.         }
  371.     }
  372.  
  373.     #   determine output file
  374.     my $dso_file;
  375.     if ($opt_o eq '') {
  376.         if ($#srcs > -1) {
  377.             $dso_file = $srcs[0];
  378.             $dso_file =~ s|\.[^.]+$|.so|;
  379.         }
  380.         elsif ($#objs > -1) {
  381.             $dso_file = $objs[0];
  382.             $dso_file =~ s|\.[^.]+$|.so|;
  383.         }
  384.         else {
  385.             $dso_file = "mod_unknown.so";
  386.         }
  387.     }
  388.     else {
  389.         $dso_file = $opt_o;
  390.     }
  391.  
  392.     #   create compilation commands
  393.     my @cmds = ();
  394.     my $opt = '';
  395.     my ($opt_Wc, $opt_I, $opt_D);
  396.     foreach $opt_Wc (@opt_W) {
  397.         $opt .= "$1 " if ($opt_Wc =~ m|^\s*c,(.*)$|);
  398.     }
  399.     foreach $opt_I (@opt_I) {
  400.         $opt .= qq{ /I"$opt_I" };
  401.     }
  402.     foreach $opt_D (@opt_D) {
  403.         $opt .= qq{ /D "$opt_D" };
  404.     }
  405.     my $cflags = "$CFG_CFLAGS";
  406.     if ($opt_d) {
  407.         $cflags =~ s!NDEBUG!DEBUG!;
  408.         $cflags .= ' /Zi';
  409.         $cflags =~ s!/MD !/MDd !;
  410.     }
  411.     my $s;
  412.     my $mod;
  413.     foreach $s (@srcs) {
  414.         my $slo = $s;
  415.         $slo =~ s|\.c$|.slo|;
  416.         my $lo = $s;
  417.         $lo =~ s|\.c$|.lo|;
  418.         my $la = $s;
  419.         $la =~ s|\.c$|.la|;
  420.         my $o = $s;
  421.         $o =~ s|\.c$|.o|;
  422.         push(@cmds, qq{$CFG_CC $cflags -I"$CFG_INCLUDEDIR" $opt /c /Fo$lo $s});
  423.         unshift(@objs, $lo);
  424.     }
  425.  
  426.     #   create link command
  427.     my $o;
  428.     my $lo;
  429.     $opt = '';
  430.     foreach $o (@objs) {
  431.         $lo .= " $o";
  432.     }
  433.     my ($opt_Wl, $opt_L, $opt_l);
  434.     foreach $opt_Wl (@opt_W) {
  435.         if ($CFG_CC !~ m/gcc$/) {
  436.             $opt .= " $1" if ($opt_Wl =~ m|^\s*l,(.*)$|);
  437.         } else {
  438.             $opt .= " -W$opt_Wl";
  439.         }
  440.     }
  441.     foreach $opt_L (@opt_L) {
  442.         $opt .= qq{ /libpath:"$opt_L" };
  443.     }
  444.     foreach $opt_l (@opt_l) {
  445.         $opt_l .= '.lib' unless ($opt_l =~ /\.lib$/); 
  446.         $opt .= " $opt_l";
  447.     }
  448.  
  449.     if ($opt_p == 1) {
  450.         $opt .= " ".$aprutil_libname." ".$apr_libname;
  451.     }
  452.     else {
  453.         my $apr_ldflags;
  454.         $opt .= " $apr_ldflags";
  455.     }
  456.     my $ldflags = "$CFG_LDFLAGS";
  457.     if ($opt_d) {
  458.         $ldflags .= ' /debug';
  459.     }
  460.     push(@cmds, "$CFG_LD $ldflags /out:$dso_file $opt $lo");
  461.  
  462.     #   execute the commands
  463.     &execute_cmds(@cmds);
  464.  
  465.     #   allow one-step compilation and installation
  466.     if ($opt_i or $opt_e) {
  467.         @args = ( $dso_file );
  468.     }
  469. }
  470.  
  471. if ($opt_i or $opt_e) {
  472.     ##
  473.     ##  SHARED OBJECT INSTALLATION
  474.     ##
  475.     unless (-d $CFG_LIBEXECDIR) {
  476.         die "Directory $CFG_LIBEXECDIR not found";
  477.     }
  478.     #   determine installation commands
  479.     #   and corresponding LoadModule/AddModule directives
  480.     my @lmd = ();
  481.     my @amd = ();
  482.     my @cmds = ();
  483.     my $f;
  484.     foreach $f (@args) {
  485.         my $end = qr{(\.so|\.la)$};
  486.         if ($f !~ m!$end!) {
  487.             error("file $f is not a shared object");
  488.             exit(1);
  489.         }
  490.         my $t = $f;
  491.         $t =~ s|^.+/([^/]+)$|$1|;
  492.         $t =~ s|\.la$|\.so|;
  493.         (my $libf = $f) =~ s!$end!.lib!;
  494.         (my $libt = $t) =~ s!$end!.lib!;
  495.         (my $pdbf = $f) =~ s!$end!.pdb!;
  496.         (my $pdbt = $t) =~ s!$end!.pdb!;
  497.  
  498.         if ($opt_i) {
  499.             push(@cmds, "$CP $f $CFG_LIBEXECDIR");
  500.             push(@cmds, "$CHMOD 755 $CFG_LIBEXECDIR\\$t");
  501.             if (-f $libf) {
  502.                 push(@cmds, "$CP $libf $CFG_LIBDIR");
  503.                 push(@cmds, "$CHMOD 755 $CFG_LIBDIR\\$libt");
  504.             }
  505.             if ($opt_d and -f $pdbf) {
  506.                 push(@cmds, "$CP $pdbf $CFG_LIBEXECDIR");
  507.                 push(@cmds, "$CHMOD 755 $CFG_LIBEXECDIR\\$pdbt");
  508.             }
  509.         }
  510.  
  511.         #   determine module symbolname and filename
  512.         my $filename = '';
  513.         if ($name eq 'unknown') {
  514.             $name = '';
  515.             my $base = $f;
  516.             $base =~ s|\.[^.]+$||;
  517.             if (-f "$base.c") {
  518.                 open(FP, "<$base.c");
  519.                 my $content = join('', <FP>);
  520.                 close(FP);
  521.                 if ($content =~ m|.*module\s+(?:AP_MODULE_DECLARE_DATA\s+)?([a-zA-Z0-9_]+)_module\s*=\s*.*|s) {
  522.                     $name = "$1";
  523.                     $filename = "$base.c";
  524.                     $filename =~ s|^[^/]+/||;
  525.                 }
  526.             }
  527.             if ($name eq '') {
  528.                 if ($base =~ m|.*mod_([a-zA-Z0-9_]+)\..+|) {
  529.                     $name = "$1";
  530.                     $filename = $base;
  531.                     $filename =~ s|^[^/]+/||;
  532.                 }
  533.             }
  534.             if ($name eq '') {
  535.                 error("Sorry, cannot determine bootstrap symbol name");
  536.                 error("Please specify one with option `-n'");
  537.                 exit(1);
  538.             }
  539.         }
  540.         if ($filename eq '') {
  541.             $filename = "mod_${name}.c";
  542.         }
  543.         my $dir = $CFG_LIBEXECDIR;
  544.         $dir =~ s|^$CFG_PREFIX/?||;
  545.         $dir =~ s|(.)$|$1/|;
  546.         $dir =~ s|\\|/|g;
  547.         $t =~ s|\.la$|.so|;
  548.         push(@lmd, 
  549.              sprintf("LoadModule %-18s %s", "${name}_module", qq{"$dir$t"}));
  550.         push(@amd, sprintf("AddModule %s", $filename));
  551.     }
  552.  
  553.     #   execute the commands
  554.     &execute_cmds(@cmds);
  555.  
  556.     #   activate module via LoadModule/AddModule directive
  557.     if ($opt_a or $opt_A) {
  558.         if (not -f "$CFG_SYSCONFDIR/$CFG_SYSCONF") {
  559.             error("Config file $CFG_SYSCONFDIR/$CFG_SYSCONF not found");
  560.             exit(1);
  561.         }
  562.  
  563.         open(FP, "<$CFG_SYSCONFDIR/$CFG_SYSCONF") 
  564.             || die "Cannot open $CFG_SYSCONFDIR/$CFG_SYSCONF: $!";
  565.         my $content = join('', <FP>);
  566.         close(FP);
  567.  
  568.         if ($content !~ m|\n\#?\s*LoadModule\s+|) {
  569.             error("Activation failed for custom $CFG_SYSCONFDIR/$CFG_SYSCONF file.");
  570.             error("At least one `LoadModule' directive already has to exist.");
  571.             exit(1);
  572.         }
  573.  
  574.         my $lmd;
  575.         my $c = '';
  576.         $c = '#' if ($opt_A);
  577.         foreach $lmd (@lmd) {
  578.             my $what = $opt_A ? "preparing" : "activating";
  579.             if ($content !~ m|\n\#?\s*$lmd|) {
  580.                 # check for open <containers>, so that the new LoadModule
  581.                 # directive always appears *outside* of an <container>.
  582.  
  583.                 my $before = 
  584.                     ($content =~ m|^(.*\n)\#?\s*LoadModule\s+[^\n]+\n|s)[0];
  585.  
  586.                 # the '()=' trick forces list context and the scalar
  587.                 # assignment counts the number of list members (aka number
  588.                 # of matches) then
  589.                 my $cntopen = () = ($before =~ m|^\s*<[^/].*$|mg);
  590.                 my $cntclose = () = ($before =~ m|^\s*</.*$|mg);
  591.  
  592.                 if ($cntopen == $cntclose) {
  593.                     # fine. Last LoadModule is contextless.
  594.                     $content =~ s|^(.*\n\#?\s*LoadModule\s+[^\n]+\n)|$1$c$lmd\n|s;
  595.                 }
  596.                 elsif ($cntopen < $cntclose) {
  597.                     error('Configuration file is not valid. There are sections'
  598.                           . ' closed before opened.');
  599.                     exit(1);
  600.                 }
  601.                 else {
  602.                     # put our cmd after the section containing the last
  603.                     # LoadModule.
  604.                     my $found =
  605.                         $content =~ s!\A (  # string and capture start
  606.                                           (?:(?:
  607.                                               ^\s*  # start of conf line with a
  608.                                               (?:[^<]|<[^/]) # directive which
  609.                                                              # does not
  610.                                                              # start with '</'
  611.                                               
  612.                                               .*(?:$)\n  # rest of the line.
  613.                                                  # the '$' is in parentheses
  614.                                                  # to avoid misinterpreting
  615.                                                  # the string "$\" as
  616.                                                  # perl variable.
  617.                                                  
  618.                                                 )* # catch as much as possible
  619.                                                    # of such lines. (including
  620.                                                    # zero)
  621.                                               
  622.                                               ^\s*</.*(?:$)\n? 
  623.                                                    # after the above, we
  624.                                                    # expect a config line with
  625.                                                    # a closing container (</)
  626.                                                        
  627.                                                       ) {$cntopen}       
  628.                                               # the whole pattern (bunch
  629.                                               # of lines that end up with
  630.                                               # a closing directive) must
  631.                                               # be repeated $cntopen
  632.                                               # times. That's it.
  633.                                               # Simple, eh? ;-)
  634.                                     
  635.                                              )  # capture end  
  636.                                            !$1$c$lmd\n!mx;  
  637.                     unless ($found) {
  638.                         error('Configuration file is not valid. There are '
  639.                               . 'sections opened and not closed.');
  640.                         exit(1);
  641.                     }
  642.                 }
  643.             }
  644.             else {
  645.                 # replace already existing LoadModule line
  646.                 $content =~ s|^(.*\n)\#?\s*$lmd[^\n]*\n|$1$c$lmd\n|s;
  647.             }
  648.             $lmd =~ m|LoadModule\s+(.+?)_module.*|;
  649.             notice("[$what module `$1' in $CFG_SYSCONFDIR\\$CFG_SYSCONF]");
  650.         } 
  651.         my $amd;
  652.         foreach $amd (@amd) {
  653.             if ($content !~ m|\n\#?\s*$amd|) {
  654.                 $content =~ s|^(.*\n\#?\s*AddModule\s+[^\n]+\n)|$1$c$amd\n|sg;
  655.             } 
  656.             else {
  657.                 $content =~ s|^(.*\n)\#?\s*$amd[^\n]*\n|$1$c$amd\n|sg;
  658.             }
  659.         }
  660.  
  661.         if (@lmd or @amd) {
  662.             my $conf = catfile $CFG_SYSCONFDIR, $CFG_SYSCONF;
  663.             my $conf_new = $conf . '.new';
  664.             my $conf_bak = $conf . '.bak';
  665.             if (open(FP, '>', $conf_new)) {
  666.                 print FP $content;
  667.                 close(FP);
  668.                 copy($conf, $conf_bak) or
  669.                          die "Backup of $conf failed: $!";
  670.                 copy($conf_new, $conf) or
  671.                          die "Copying $conf_new to $conf failed: $!";
  672.                 unlink $conf_new or
  673.                     die "Removing $conf_new failed: $!";
  674.             } 
  675.             else {
  676.                 notice("unable to open configuration file $conf_new");
  677.             }
  678.         }
  679.     }
  680. }
  681.  
  682. sub error{
  683.     print STDERR "apxs:Error: $_[0].\n";
  684. }
  685.  
  686. sub notice{
  687.     print STDERR "$_[0]\n";
  688. }
  689.  
  690. ##EOF##
  691. __DATA__
  692. ##
  693. ##  Makefile -- Build procedure for sample %NAME% Apache module
  694. ##  Autogenerated via ``apxs -n %NAME% -g''.
  695. ##
  696.  
  697. builddir=.
  698. top_srcdir=%PREFIX%
  699. top_builddir=%PREFIX%
  700.  
  701. #   the used tools
  702. APXS=apxs
  703. APACHECTL=Apache.exe -k
  704.  
  705. #   additional defines, includes and libraries
  706. #DEFS=-Dmy_define=my_value
  707. #INCLUDES=-Imy/include/dir
  708. #LIBS=-Lmy/lib/dir -lmylib
  709.  
  710. #   the default target
  711. all: local-shared-build
  712.  
  713. #   install the shared object file into Apache 
  714. install: install-modules
  715.  
  716. #   cleanup
  717. clean:
  718.         -@erase mod_%NAME%.lo mod_%NAME%.ilk mod_%NAME%.so mod_%NAME%.lib mod_%NAME%.exp mod_%NAME%.pdb
  719.  
  720. #   simple test
  721. test: reload
  722.     GET http://localhost/%NAME%
  723.  
  724. #   install and activate shared object by reloading Apache to
  725. #   force a reload of the shared object file
  726. reload: install restart
  727.  
  728. #   the general Apache start/restart/stop
  729. #   procedures
  730. start:
  731.     $(APACHECTL) start
  732. restart:
  733.     $(APACHECTL) restart
  734. stop:
  735.     $(APACHECTL) stop
  736.  
  737. -=#=-
  738. /* 
  739. **  mod_%NAME%.c -- Apache sample %NAME% module
  740. **  [Autogenerated via ``apxs -n %NAME% -g'']
  741. **
  742. **  To play with this sample module first compile it into a
  743. **  DSO file and install it into Apache's modules directory 
  744. **  by running:
  745. **
  746. **    $ apxs -c -i mod_%NAME%.c
  747. **
  748. **  Then activate it in Apache's %SYSCONF% file for instance
  749. **  for the URL /%NAME% in as follows:
  750. **
  751. **    #   %SYSCONF%
  752. **    LoadModule %NAME%_module modules/mod_%NAME%.so
  753. **    <Location /%NAME%>
  754. **    SetHandler %NAME%
  755. **    </Location>
  756. **
  757. **  Then after restarting Apache via
  758. **
  759. **    $ apachectl restart
  760. **
  761. **  you immediately can request the URL /%NAME% and watch for the
  762. **  output of this module. This can be achieved for instance via:
  763. **
  764. **    $ lynx -mime_header http://localhost/%NAME% 
  765. **
  766. **  The output should be similar to the following one:
  767. **
  768. **    HTTP/1.1 200 OK
  769. **    Date: Tue, 31 Mar 1998 14:42:22 GMT
  770. **    Server: Apache/1.3.4 (Unix)
  771. **    Connection: close
  772. **    Content-Type: text/html
  773. **  
  774. **    The sample page from mod_%NAME%.c
  775. */ 
  776.  
  777. #include "httpd.h"
  778. #include "http_config.h"
  779. #include "http_protocol.h"
  780. #include "ap_config.h"
  781.  
  782. /* The sample content handler */
  783. static int %NAME%_handler(request_rec *r)
  784. {
  785.     if (strcmp(r->handler, "%NAME%")) {
  786.         return DECLINED;
  787.     }
  788.     r->content_type = "text/html";      
  789.  
  790.     if (!r->header_only)
  791.         ap_rputs("The sample page from mod_%NAME%.c\n", r);
  792.     return OK;
  793. }
  794.  
  795. static void %NAME%_register_hooks(apr_pool_t *p)
  796. {
  797.     ap_hook_handler(%NAME%_handler, NULL, NULL, APR_HOOK_MIDDLE);
  798. }
  799.  
  800. /* Dispatch list for API hooks */
  801. module AP_MODULE_DECLARE_DATA %NAME%_module = {
  802.     STANDARD20_MODULE_STUFF, 
  803.     NULL,                  /* create per-dir    config structures */
  804.     NULL,                  /* merge  per-dir    config structures */
  805.     NULL,                  /* create per-server config structures */
  806.     NULL,                  /* merge  per-server config structures */
  807.     NULL,                  /* table of config file commands       */
  808.     %NAME%_register_hooks  /* register hooks                      */
  809. };
  810.  
  811. __END__
  812. :endofperl
  813.